package com.own.component.common.base.service.hook;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.own.component.common.base.entity.BaseQuery;
import com.own.component.common.base.entity.po.BaseBean;
import org.apache.commons.lang3.StringUtils;

import java.io.Serializable;
import java.util.Collections;
import java.util.List;

/**
 * BaseWrapperHook
 *
 * @author chenxueli
 * @date 2022-06-15 03:14:15
 */
public interface BaseWrapperHook<
        PO extends BaseBean,
        QUERY extends BaseQuery
        > {

    /**
     * 获取查询条件
     *
     * @return 查询条件对象
     */
    default QueryWrapper<PO> queryWrapper() {
        return new QueryWrapper<>();
    }

    /**
     * 获取查询条件
     *
     * @param query 查询条件
     * @return 查询条件对象
     */
    default QueryWrapper<PO> queryWrapper(QUERY query) {
        return queryWrapper();
    }

    /**
     * 获取查询条件
     *
     * @return 查询条件对象
     */
    default LambdaQueryWrapper<PO> lambdaQueryWrapper() {
        var wrapper = queryWrapper().lambda();
        defaultSort(wrapper);
        return wrapper;
    }

    /**
     * 获取查询条件
     *
     * @param query 查询条件
     * @return 查询条件对象
     */
    default LambdaQueryWrapper<PO> lambdaQueryWrapper(QUERY query) {
        return lambdaQueryWrapper(query, true);
    }

    /**
     * 获取查询条件
     *
     * @param query    查询条件
     * @param keywords 是否需要用通用的关键字
     * @return 查询条件对象
     */
    default LambdaQueryWrapper<PO> lambdaQueryWrapper(QUERY query, boolean keywords) {
        if (query == null) {
            return lambdaQueryWrapper();
        }
        var wrapper = queryWrapper(query).lambda();
        if (!keywords) {
            return wrapper;
        }
        var keywordsList = keywords(query);
        if (keywordsList.isEmpty() || StringUtils.isBlank(query.getKeywords())) {
            return wrapper;
        }
        wrapper.and(item -> {
            for (var i = 0; i < keywordsList.size(); i++) {
                var keyword = keywordsList.get(i);
                if (i == 0) {
                    item.like(keyword, query.getKeywords());
                    continue;
                }
                item.or().like(keyword, query.getKeywords());
            }
        });
        return wrapper;
    }

    /**
     * 关键字查询条件
     *
     * @param query 查询条件
     * @return 关键字查询列表
     */
    default List<SFunction<PO, Serializable>> keywords(QUERY query) {
        return Collections.emptyList();
    }

    /**
     * 默认的排序信息
     *
     * @param wrapper 查询条件
     */
    default void defaultSort(LambdaQueryWrapper<PO> wrapper) {
    }

}
